package com.ourteam.workspace.dao;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import net.dao.BaseQueryBean;
import net.dao.BaseWhereCriterion;
import net.dao.IDataAccessInterface;
import org.apache.commons.lang.StringUtils;

/**
 * Template Name : DAO查询对象 Template Version : 1 Template Last Modfiy Date : Sat Aug 19 10:06:32 CST
 * 2017 Auto Generate Date : 2018-11-30 18:42:29 Warning ! This file will be overwrite when
 * regenerate !
 */
public class WorkspaceDAOQueryBean extends BaseQueryBean {

  public WorkspaceDAOQueryBean() {
    super();
  }

  public WorkspaceDAOQueryBean(BaseQueryBean aQueryBean) {
    super(aQueryBean);
  }

  public WorkspaceDAOQueryBean(BaseQueryBean aQueryBean, Map tableReplaceMap) {
    super(aQueryBean, tableReplaceMap);
  }

  public Criteria createCriteria() {

    Criteria criteria = createCriteriaInternal();
    if (oredCriteria.size() == 0) {
      oredCriteria.add(criteria);
    }
    return criteria;
  }

  protected Criteria createCriteriaInternal() {
    return new Criteria(this);
  }

  public void addIdSelectProperty() {
    addIdSelectProperty("id");
  }

  public void addIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceDAO.Id, aAlias);
    } else {
      addSelectProperty(IWorkspaceDAO.Id, "id");
    }
  }

  public void addCreateTimeSelectProperty() {
    addCreateTimeSelectProperty("createTime");
  }

  public void addCreateTimeSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceDAO.CreateTime, aAlias);
    } else {
      addSelectProperty(IWorkspaceDAO.CreateTime, "createTime");
    }
  }

  public void addNameSelectProperty() {
    addNameSelectProperty("name");
  }

  public void addNameSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceDAO.Name, aAlias);
    } else {
      addSelectProperty(IWorkspaceDAO.Name, "name");
    }
  }

  public void addStatusSelectProperty() {
    addStatusSelectProperty("status");
  }

  public void addStatusSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceDAO.Status, aAlias);
    } else {
      addSelectProperty(IWorkspaceDAO.Status, "status");
    }
  }

  public void addWorkspacePathSelectProperty() {
    addWorkspacePathSelectProperty("workspacePath");
  }

  public void addWorkspacePathSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceDAO.WorkspacePath, aAlias);
    } else {
      addSelectProperty(IWorkspaceDAO.WorkspacePath, "workspacePath");
    }
  }

  public void addWorkspaceTypeSelectProperty() {
    addWorkspaceTypeSelectProperty("workspaceType");
  }

  public void addWorkspaceTypeSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceDAO.WorkspaceType, aAlias);
    } else {
      addSelectProperty(IWorkspaceDAO.WorkspaceType, "workspaceType");
    }
  }

  public void addDescriptionSelectProperty() {
    addDescriptionSelectProperty("description");
  }

  public void addDescriptionSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceDAO.Description, aAlias);
    } else {
      addSelectProperty(IWorkspaceDAO.Description, "description");
    }
  }

  public void addSubmitterIdSelectProperty() {
    addSubmitterIdSelectProperty("submitterId");
  }

  public void addSubmitterIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceDAO.SubmitterId, aAlias);
    } else {
      addSelectProperty(IWorkspaceDAO.SubmitterId, "submitterId");
    }
  }

  public void addCreatorNameSelectProperty() {
    addCreatorNameSelectProperty("creatorName");
  }

  public void addCreatorNameSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceDAO.CreatorName, aAlias);
    } else {
      addSelectProperty(IWorkspaceDAO.CreatorName, "creatorName");
    }
  }

  public void addLastModifierNameSelectProperty() {
    addLastModifierNameSelectProperty("lastModifierName");
  }

  public void addLastModifierNameSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceDAO.LastModifierName, aAlias);
    } else {
      addSelectProperty(IWorkspaceDAO.LastModifierName, "lastModifierName");
    }
  }

  public void addLastModifyTimeSelectProperty() {
    addLastModifyTimeSelectProperty("lastModifyTime");
  }

  public void addLastModifyTimeSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceDAO.LastModifyTime, aAlias);
    } else {
      addSelectProperty(IWorkspaceDAO.LastModifyTime, "lastModifyTime");
    }
  }

  public void addAllSelectProperties() {

    addIdSelectProperty();

    addCreateTimeSelectProperty();

    addNameSelectProperty();

    addStatusSelectProperty();

    addWorkspacePathSelectProperty();

    addWorkspaceTypeSelectProperty();

    addDescriptionSelectProperty();

    addSubmitterIdSelectProperty();

    addCreatorNameSelectProperty();

    addLastModifierNameSelectProperty();

    addLastModifyTimeSelectProperty();
  }

  public static class Criteria extends BaseWhereCriterion<WorkspaceDAOQueryBean> {

    protected Criteria(WorkspaceDAOQueryBean aParentObject) {
      super(aParentObject);
    }

    public Criteria andIdIsNull() {
      addCriterion(IWorkspaceDAO.Id + " is null");
      return this;
    }

    public Criteria andIdIsNotNull() {
      addCriterion(IWorkspaceDAO.Id + " is not null");
      return this;
    }

    public Criteria andIdIsNotEmpty() {
      addCriterion(IWorkspaceDAO.Id + " is not null AND " + IWorkspaceDAO.Id + " <> ''");
      return this;
    }

    public Criteria andIdIsEmpty() {
      addCriterion("(" + IWorkspaceDAO.Id + " is null OR " + IWorkspaceDAO.Id + " = '')");
      return this;
    }

    public Criteria andIdEqualTo(long value) {
      return andIdEqualTo(Long.valueOf(value));
    }

    public Criteria andIdEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceDAO.Id + " = ", value, "id");
      return this;
    }

    public Criteria andIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Id);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Id + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdNotEqualTo(long value) {
      return andIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andIdNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceDAO.Id + " <>", value, "id");
      return this;
    }

    public Criteria andIdNotEqualToOrIsNull(long value) {
      return andIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(IWorkspaceDAO.Id + " is null OR " + IWorkspaceDAO.Id + " <>", value, "id");
      return this;
    }

    public Criteria andIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Id);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdNotEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Id + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdGreaterThan(long value) {
      return andIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andIdGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceDAO.Id + " >", value, "id");
      return this;
    }

    public Criteria andIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Id);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdGreaterThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Id + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdGreaterThanOrEqualTo(long value) {
      return andIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceDAO.Id + " >=", value, "id");
      return this;
    }

    public Criteria andIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Id);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Id + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdLessThan(long value) {
      return andIdLessThan(Long.valueOf(value));
    }

    public Criteria andIdLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceDAO.Id + " <", value, "id");
      return this;
    }

    public Criteria andIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Id);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Id + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdLessThanOrEqualTo(long value) {
      return andIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceDAO.Id + " <=", value, "id");
      return this;
    }

    public Criteria andIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Id);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Id + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdIn(long[] values) {
      if (values.length == 1) {
        return andIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceDAO.Id + " in", values, "id");
        return this;
      }
    }

    public Criteria andIdNotIn(long[] values) {
      if (values.length == 1) {
        return andIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceDAO.Id + " not in", values, "id");
        return this;
      }
    }

    public Criteria andIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andIdEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceDAO.Id + " in", values, "id");
        return this;
      }
    }

    public Criteria andIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andIdNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceDAO.Id + " not in", values, "id");
        return this;
      }
    }

    public Criteria andIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andIdEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceDAO.Id + " in", Arrays.asList(values), "id");
        return this;
      }
    }

    public Criteria andIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andIdNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceDAO.Id + " not in", Arrays.asList(values), "id");
        return this;
      }
    }

    public Criteria andIdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Id + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Id + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdBetween(long value1, long value2) {
      addCriterion(IWorkspaceDAO.Id + " between", value1, value2, "id");
      return this;
    }

    public Criteria andIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceDAO.Id + " between", value1, value2, "id");
      return this;
    }

    public Criteria andIdNotBetween(long value1, long value2) {
      addCriterion(IWorkspaceDAO.Id + " not between", value1, value2, "id");
      return this;
    }

    public Criteria andIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceDAO.Id + " not between", value1, value2, "id");
      return this;
    }

    public Criteria andCreateTimeIsNull() {
      addCriterion(IWorkspaceDAO.CreateTime + " is null");
      return this;
    }

    public Criteria andCreateTimeIsNotNull() {
      addCriterion(IWorkspaceDAO.CreateTime + " is not null");
      return this;
    }

    public Criteria andCreateTimeIsNotEmpty() {
      addCriterion(
          IWorkspaceDAO.CreateTime + " is not null AND " + IWorkspaceDAO.CreateTime + " <> ''");
      return this;
    }

    public Criteria andCreateTimeIsEmpty() {
      addCriterion(
          "(" + IWorkspaceDAO.CreateTime + " is null OR " + IWorkspaceDAO.CreateTime + " = '')");
      return this;
    }

    public Criteria andCreateTimeEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(IWorkspaceDAO.CreateTime + " = ", value, "createTime");
      return this;
    }

    public Criteria andCreateTimeEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.CreateTime);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCreateTimeEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.CreateTime + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andCreateTimeNotEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(IWorkspaceDAO.CreateTime + " <>", value, "createTime");
      return this;
    }

    public Criteria andCreateTimeNotEqualToOrIsNull(java.util.Date value) {

      addCriterionForJDBCDate(
          IWorkspaceDAO.CreateTime + " is null OR " + IWorkspaceDAO.CreateTime + " <>",
          value,
          "createTime");
      return this;
    }

    public Criteria andCreateTimeNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.CreateTime);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCreateTimeNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.CreateTime + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andCreateTimeGreaterThan(java.util.Date value) {

      addCriterionForJDBCDate(IWorkspaceDAO.CreateTime + " >", value, "createTime");
      return this;
    }

    public Criteria andCreateTimeGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.CreateTime);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCreateTimeGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.CreateTime + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andCreateTimeGreaterThanOrEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(IWorkspaceDAO.CreateTime + " >=", value, "createTime");
      return this;
    }

    public Criteria andCreateTimeGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.CreateTime);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCreateTimeGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.CreateTime + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCreateTimeLessThan(java.util.Date value) {

      addCriterionForJDBCDate(IWorkspaceDAO.CreateTime + " <", value, "createTime");
      return this;
    }

    public Criteria andCreateTimeLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.CreateTime);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCreateTimeLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.CreateTime + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andCreateTimeLessThanOrEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(IWorkspaceDAO.CreateTime + " <=", value, "createTime");
      return this;
    }

    public Criteria andCreateTimeLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.CreateTime);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCreateTimeLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.CreateTime + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCreateTimeIn(List<java.util.Date> values) {

      if (values.size() == 1) {
        return andCreateTimeEqualTo(values.get(0));
      } else {
        addCriterionForJDBCDate(IWorkspaceDAO.CreateTime + " in", values, "createTime");
        return this;
      }
    }

    public Criteria andCreateTimeNotIn(List<java.util.Date> values) {
      if (values.size() == 1) {
        return andCreateTimeNotEqualTo(values.get(0));
      } else {
        addCriterionForJDBCDate(IWorkspaceDAO.CreateTime + " not in", values, "createTime");
        return this;
      }
    }

    public Criteria andCreateTimeIn(java.util.Date[] values) {

      if (values.length == 1) {
        return andCreateTimeEqualTo(values[0]);
      } else {
        addCriterionForJDBCDate(
            IWorkspaceDAO.CreateTime + " in", Arrays.asList(values), "createTime");
        return this;
      }
    }

    public Criteria andCreateTimeNotIn(java.util.Date[] values) {
      if (values.length == 1) {
        return andCreateTimeNotEqualTo(values[0]);
      } else {
        addCriterionForJDBCDate(
            IWorkspaceDAO.CreateTime + " not in", Arrays.asList(values), "createTime");
        return this;
      }
    }

    public Criteria andCreateTimeIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.CreateTime + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCreateTimeNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.CreateTime + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCreateTimeBetween(java.util.Date value1, java.util.Date value2) {
      addCriterionForJDBCDate(IWorkspaceDAO.CreateTime + " between", value1, value2, "createTime");
      return this;
    }

    public Criteria andCreateTimeNotBetween(java.util.Date value1, java.util.Date value2) {
      addCriterionForJDBCDate(
          IWorkspaceDAO.CreateTime + " not between", value1, value2, "createTime");
      return this;
    }

    public Criteria andNameIsNull() {
      addCriterion(IWorkspaceDAO.Name + " is null");
      return this;
    }

    public Criteria andNameIsNotNull() {
      addCriterion(IWorkspaceDAO.Name + " is not null");
      return this;
    }

    public Criteria andNameIsNotEmpty() {
      addCriterion(IWorkspaceDAO.Name + " is not null AND " + IWorkspaceDAO.Name + " <> ''");
      return this;
    }

    public Criteria andNameIsEmpty() {
      addCriterion("(" + IWorkspaceDAO.Name + " is null OR " + IWorkspaceDAO.Name + " = '')");
      return this;
    }

    public Criteria andNameEqualTo(String value) {

      addCriterion(IWorkspaceDAO.Name + " = ", value, "name");
      return this;
    }

    public Criteria andNameEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Name);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andNameEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Name + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andNameNotEqualTo(String value) {

      addCriterion(IWorkspaceDAO.Name + " <>", value, "name");
      return this;
    }

    public Criteria andNameNotEqualToOrIsNull(String value) {

      addCriterion(IWorkspaceDAO.Name + " is null OR " + IWorkspaceDAO.Name + " <>", value, "name");
      return this;
    }

    public Criteria andNameNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Name);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andNameNotEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Name + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andNameGreaterThan(String value) {

      addCriterion(IWorkspaceDAO.Name + " >", value, "name");
      return this;
    }

    public Criteria andNameGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Name);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andNameGreaterThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Name + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andNameGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceDAO.Name + " >=", value, "name");
      return this;
    }

    public Criteria andNameGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Name);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andNameGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Name + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andNameLessThan(String value) {

      addCriterion(IWorkspaceDAO.Name + " <", value, "name");
      return this;
    }

    public Criteria andNameLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Name);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andNameLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Name + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andNameLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceDAO.Name + " <=", value, "name");
      return this;
    }

    public Criteria andNameLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Name);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andNameLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Name + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andNameLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceDAO.Name + " like", buffer.toString(), "name");
      return this;
    }

    public Criteria andNameNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceDAO.Name + " not like", buffer.toString(), "name");
      return this;
    }

    public Criteria andNameIn(List<String> values) {

      if (values.size() == 1) {
        return andNameEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceDAO.Name + " in", values, "name");
        return this;
      }
    }

    public Criteria andNameNotIn(List<String> values) {
      if (values.size() == 1) {
        return andNameNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceDAO.Name + " not in", values, "name");
        return this;
      }
    }

    public Criteria andNameIn(String[] values) {

      if (values.length == 1) {
        return andNameEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceDAO.Name + " in", Arrays.asList(values), "name");
        return this;
      }
    }

    public Criteria andNameNotIn(String[] values) {
      if (values.length == 1) {
        return andNameNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceDAO.Name + " not in", Arrays.asList(values), "name");
        return this;
      }
    }

    public Criteria andNameIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Name + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andNameNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Name + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andNameBetween(String value1, String value2) {
      addCriterion(IWorkspaceDAO.Name + " between", value1, value2, "name");
      return this;
    }

    public Criteria andNameNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceDAO.Name + " not between", value1, value2, "name");
      return this;
    }

    public Criteria andStatusIsNull() {
      addCriterion(IWorkspaceDAO.Status + " is null");
      return this;
    }

    public Criteria andStatusIsNotNull() {
      addCriterion(IWorkspaceDAO.Status + " is not null");
      return this;
    }

    public Criteria andStatusIsNotEmpty() {
      addCriterion(IWorkspaceDAO.Status + " is not null AND " + IWorkspaceDAO.Status + " <> ''");
      return this;
    }

    public Criteria andStatusIsEmpty() {
      addCriterion("(" + IWorkspaceDAO.Status + " is null OR " + IWorkspaceDAO.Status + " = '')");
      return this;
    }

    public Criteria andStatusEqualTo(String value) {

      addCriterion(IWorkspaceDAO.Status + " = ", value, "status");
      return this;
    }

    public Criteria andStatusEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Status);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Status + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusNotEqualTo(String value) {

      addCriterion(IWorkspaceDAO.Status + " <>", value, "status");
      return this;
    }

    public Criteria andStatusNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceDAO.Status + " is null OR " + IWorkspaceDAO.Status + " <>", value, "status");
      return this;
    }

    public Criteria andStatusNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Status);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Status + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusGreaterThan(String value) {

      addCriterion(IWorkspaceDAO.Status + " >", value, "status");
      return this;
    }

    public Criteria andStatusGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Status);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Status + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceDAO.Status + " >=", value, "status");
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Status);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Status + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLessThan(String value) {

      addCriterion(IWorkspaceDAO.Status + " <", value, "status");
      return this;
    }

    public Criteria andStatusLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Status);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Status + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceDAO.Status + " <=", value, "status");
      return this;
    }

    public Criteria andStatusLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Status);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Status + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceDAO.Status + " like", buffer.toString(), "status");
      return this;
    }

    public Criteria andStatusNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceDAO.Status + " not like", buffer.toString(), "status");
      return this;
    }

    public Criteria andStatusIn(List<String> values) {

      if (values.size() == 1) {
        return andStatusEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceDAO.Status + " in", values, "status");
        return this;
      }
    }

    public Criteria andStatusNotIn(List<String> values) {
      if (values.size() == 1) {
        return andStatusNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceDAO.Status + " not in", values, "status");
        return this;
      }
    }

    public Criteria andStatusIn(String[] values) {

      if (values.length == 1) {
        return andStatusEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceDAO.Status + " in", Arrays.asList(values), "status");
        return this;
      }
    }

    public Criteria andStatusNotIn(String[] values) {
      if (values.length == 1) {
        return andStatusNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceDAO.Status + " not in", Arrays.asList(values), "status");
        return this;
      }
    }

    public Criteria andStatusIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Status + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Status + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusBetween(String value1, String value2) {
      addCriterion(IWorkspaceDAO.Status + " between", value1, value2, "status");
      return this;
    }

    public Criteria andStatusNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceDAO.Status + " not between", value1, value2, "status");
      return this;
    }

    public Criteria andWorkspacePathIsNull() {
      addCriterion(IWorkspaceDAO.WorkspacePath + " is null");
      return this;
    }

    public Criteria andWorkspacePathIsNotNull() {
      addCriterion(IWorkspaceDAO.WorkspacePath + " is not null");
      return this;
    }

    public Criteria andWorkspacePathIsNotEmpty() {
      addCriterion(
          IWorkspaceDAO.WorkspacePath
              + " is not null AND "
              + IWorkspaceDAO.WorkspacePath
              + " <> ''");
      return this;
    }

    public Criteria andWorkspacePathIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceDAO.WorkspacePath
              + " is null OR "
              + IWorkspaceDAO.WorkspacePath
              + " = '')");
      return this;
    }

    public Criteria andWorkspacePathEqualTo(String value) {

      addCriterion(IWorkspaceDAO.WorkspacePath + " = ", value, "workspacePath");
      return this;
    }

    public Criteria andWorkspacePathEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.WorkspacePath);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspacePathEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.WorkspacePath + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspacePathNotEqualTo(String value) {

      addCriterion(IWorkspaceDAO.WorkspacePath + " <>", value, "workspacePath");
      return this;
    }

    public Criteria andWorkspacePathNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceDAO.WorkspacePath + " is null OR " + IWorkspaceDAO.WorkspacePath + " <>",
          value,
          "workspacePath");
      return this;
    }

    public Criteria andWorkspacePathNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.WorkspacePath);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspacePathNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.WorkspacePath + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspacePathGreaterThan(String value) {

      addCriterion(IWorkspaceDAO.WorkspacePath + " >", value, "workspacePath");
      return this;
    }

    public Criteria andWorkspacePathGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.WorkspacePath);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspacePathGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.WorkspacePath + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspacePathGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceDAO.WorkspacePath + " >=", value, "workspacePath");
      return this;
    }

    public Criteria andWorkspacePathGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.WorkspacePath);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspacePathGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.WorkspacePath + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspacePathLessThan(String value) {

      addCriterion(IWorkspaceDAO.WorkspacePath + " <", value, "workspacePath");
      return this;
    }

    public Criteria andWorkspacePathLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.WorkspacePath);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspacePathLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.WorkspacePath + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspacePathLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceDAO.WorkspacePath + " <=", value, "workspacePath");
      return this;
    }

    public Criteria andWorkspacePathLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.WorkspacePath);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspacePathLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.WorkspacePath + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspacePathLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceDAO.WorkspacePath + " like", buffer.toString(), "workspacePath");
      return this;
    }

    public Criteria andWorkspacePathNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceDAO.WorkspacePath + " not like", buffer.toString(), "workspacePath");
      return this;
    }

    public Criteria andWorkspacePathIn(List<String> values) {

      if (values.size() == 1) {
        return andWorkspacePathEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceDAO.WorkspacePath + " in", values, "workspacePath");
        return this;
      }
    }

    public Criteria andWorkspacePathNotIn(List<String> values) {
      if (values.size() == 1) {
        return andWorkspacePathNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceDAO.WorkspacePath + " not in", values, "workspacePath");
        return this;
      }
    }

    public Criteria andWorkspacePathIn(String[] values) {

      if (values.length == 1) {
        return andWorkspacePathEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceDAO.WorkspacePath + " in", Arrays.asList(values), "workspacePath");
        return this;
      }
    }

    public Criteria andWorkspacePathNotIn(String[] values) {
      if (values.length == 1) {
        return andWorkspacePathNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceDAO.WorkspacePath + " not in", Arrays.asList(values), "workspacePath");
        return this;
      }
    }

    public Criteria andWorkspacePathIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.WorkspacePath + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspacePathNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.WorkspacePath + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspacePathBetween(String value1, String value2) {
      addCriterion(IWorkspaceDAO.WorkspacePath + " between", value1, value2, "workspacePath");
      return this;
    }

    public Criteria andWorkspacePathNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceDAO.WorkspacePath + " not between", value1, value2, "workspacePath");
      return this;
    }

    public Criteria andWorkspaceTypeIsNull() {
      addCriterion(IWorkspaceDAO.WorkspaceType + " is null");
      return this;
    }

    public Criteria andWorkspaceTypeIsNotNull() {
      addCriterion(IWorkspaceDAO.WorkspaceType + " is not null");
      return this;
    }

    public Criteria andWorkspaceTypeIsNotEmpty() {
      addCriterion(
          IWorkspaceDAO.WorkspaceType
              + " is not null AND "
              + IWorkspaceDAO.WorkspaceType
              + " <> ''");
      return this;
    }

    public Criteria andWorkspaceTypeIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceDAO.WorkspaceType
              + " is null OR "
              + IWorkspaceDAO.WorkspaceType
              + " = '')");
      return this;
    }

    public Criteria andWorkspaceTypeEqualTo(String value) {

      addCriterion(IWorkspaceDAO.WorkspaceType + " = ", value, "workspaceType");
      return this;
    }

    public Criteria andWorkspaceTypeEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.WorkspaceType);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceTypeEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.WorkspaceType + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceTypeNotEqualTo(String value) {

      addCriterion(IWorkspaceDAO.WorkspaceType + " <>", value, "workspaceType");
      return this;
    }

    public Criteria andWorkspaceTypeNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceDAO.WorkspaceType + " is null OR " + IWorkspaceDAO.WorkspaceType + " <>",
          value,
          "workspaceType");
      return this;
    }

    public Criteria andWorkspaceTypeNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.WorkspaceType);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceTypeNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.WorkspaceType + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceTypeGreaterThan(String value) {

      addCriterion(IWorkspaceDAO.WorkspaceType + " >", value, "workspaceType");
      return this;
    }

    public Criteria andWorkspaceTypeGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.WorkspaceType);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceTypeGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.WorkspaceType + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceTypeGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceDAO.WorkspaceType + " >=", value, "workspaceType");
      return this;
    }

    public Criteria andWorkspaceTypeGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.WorkspaceType);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceTypeGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.WorkspaceType + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceTypeLessThan(String value) {

      addCriterion(IWorkspaceDAO.WorkspaceType + " <", value, "workspaceType");
      return this;
    }

    public Criteria andWorkspaceTypeLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.WorkspaceType);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceTypeLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.WorkspaceType + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceTypeLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceDAO.WorkspaceType + " <=", value, "workspaceType");
      return this;
    }

    public Criteria andWorkspaceTypeLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.WorkspaceType);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceTypeLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.WorkspaceType + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceTypeLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceDAO.WorkspaceType + " like", buffer.toString(), "workspaceType");
      return this;
    }

    public Criteria andWorkspaceTypeNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceDAO.WorkspaceType + " not like", buffer.toString(), "workspaceType");
      return this;
    }

    public Criteria andWorkspaceTypeIn(List<String> values) {

      if (values.size() == 1) {
        return andWorkspaceTypeEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceDAO.WorkspaceType + " in", values, "workspaceType");
        return this;
      }
    }

    public Criteria andWorkspaceTypeNotIn(List<String> values) {
      if (values.size() == 1) {
        return andWorkspaceTypeNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceDAO.WorkspaceType + " not in", values, "workspaceType");
        return this;
      }
    }

    public Criteria andWorkspaceTypeIn(String[] values) {

      if (values.length == 1) {
        return andWorkspaceTypeEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceDAO.WorkspaceType + " in", Arrays.asList(values), "workspaceType");
        return this;
      }
    }

    public Criteria andWorkspaceTypeNotIn(String[] values) {
      if (values.length == 1) {
        return andWorkspaceTypeNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceDAO.WorkspaceType + " not in", Arrays.asList(values), "workspaceType");
        return this;
      }
    }

    public Criteria andWorkspaceTypeIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.WorkspaceType + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceTypeNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.WorkspaceType + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceTypeBetween(String value1, String value2) {
      addCriterion(IWorkspaceDAO.WorkspaceType + " between", value1, value2, "workspaceType");
      return this;
    }

    public Criteria andWorkspaceTypeNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceDAO.WorkspaceType + " not between", value1, value2, "workspaceType");
      return this;
    }

    public Criteria andDescriptionIsNull() {
      addCriterion(IWorkspaceDAO.Description + " is null");
      return this;
    }

    public Criteria andDescriptionIsNotNull() {
      addCriterion(IWorkspaceDAO.Description + " is not null");
      return this;
    }

    public Criteria andDescriptionIsNotEmpty() {
      addCriterion(
          IWorkspaceDAO.Description + " is not null AND " + IWorkspaceDAO.Description + " <> ''");
      return this;
    }

    public Criteria andDescriptionIsEmpty() {
      addCriterion(
          "(" + IWorkspaceDAO.Description + " is null OR " + IWorkspaceDAO.Description + " = '')");
      return this;
    }

    public Criteria andDescriptionEqualTo(String value) {

      addCriterion(IWorkspaceDAO.Description + " = ", value, "description");
      return this;
    }

    public Criteria andDescriptionEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Description);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDescriptionEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Description + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andDescriptionNotEqualTo(String value) {

      addCriterion(IWorkspaceDAO.Description + " <>", value, "description");
      return this;
    }

    public Criteria andDescriptionNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceDAO.Description + " is null OR " + IWorkspaceDAO.Description + " <>",
          value,
          "description");
      return this;
    }

    public Criteria andDescriptionNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Description);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDescriptionNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Description + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andDescriptionGreaterThan(String value) {

      addCriterion(IWorkspaceDAO.Description + " >", value, "description");
      return this;
    }

    public Criteria andDescriptionGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Description);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDescriptionGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Description + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andDescriptionGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceDAO.Description + " >=", value, "description");
      return this;
    }

    public Criteria andDescriptionGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Description);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDescriptionGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Description + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDescriptionLessThan(String value) {

      addCriterion(IWorkspaceDAO.Description + " <", value, "description");
      return this;
    }

    public Criteria andDescriptionLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Description);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDescriptionLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Description + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andDescriptionLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceDAO.Description + " <=", value, "description");
      return this;
    }

    public Criteria andDescriptionLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.Description);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDescriptionLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Description + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDescriptionLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceDAO.Description + " like", buffer.toString(), "description");
      return this;
    }

    public Criteria andDescriptionNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceDAO.Description + " not like", buffer.toString(), "description");
      return this;
    }

    public Criteria andDescriptionIn(List<String> values) {

      if (values.size() == 1) {
        return andDescriptionEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceDAO.Description + " in", values, "description");
        return this;
      }
    }

    public Criteria andDescriptionNotIn(List<String> values) {
      if (values.size() == 1) {
        return andDescriptionNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceDAO.Description + " not in", values, "description");
        return this;
      }
    }

    public Criteria andDescriptionIn(String[] values) {

      if (values.length == 1) {
        return andDescriptionEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceDAO.Description + " in", Arrays.asList(values), "description");
        return this;
      }
    }

    public Criteria andDescriptionNotIn(String[] values) {
      if (values.length == 1) {
        return andDescriptionNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceDAO.Description + " not in", Arrays.asList(values), "description");
        return this;
      }
    }

    public Criteria andDescriptionIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Description + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDescriptionNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.Description + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDescriptionBetween(String value1, String value2) {
      addCriterion(IWorkspaceDAO.Description + " between", value1, value2, "description");
      return this;
    }

    public Criteria andDescriptionNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceDAO.Description + " not between", value1, value2, "description");
      return this;
    }

    public Criteria andSubmitterIdIsNull() {
      addCriterion(IWorkspaceDAO.SubmitterId + " is null");
      return this;
    }

    public Criteria andSubmitterIdIsNotNull() {
      addCriterion(IWorkspaceDAO.SubmitterId + " is not null");
      return this;
    }

    public Criteria andSubmitterIdIsNotEmpty() {
      addCriterion(
          IWorkspaceDAO.SubmitterId + " is not null AND " + IWorkspaceDAO.SubmitterId + " <> ''");
      return this;
    }

    public Criteria andSubmitterIdIsEmpty() {
      addCriterion(
          "(" + IWorkspaceDAO.SubmitterId + " is null OR " + IWorkspaceDAO.SubmitterId + " = '')");
      return this;
    }

    public Criteria andSubmitterIdEqualTo(long value) {
      return andSubmitterIdEqualTo(Long.valueOf(value));
    }

    public Criteria andSubmitterIdEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceDAO.SubmitterId + " = ", value, "submitterId");
      return this;
    }

    public Criteria andSubmitterIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.SubmitterId);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andSubmitterIdEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.SubmitterId + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andSubmitterIdNotEqualTo(long value) {
      return andSubmitterIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andSubmitterIdNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceDAO.SubmitterId + " <>", value, "submitterId");
      return this;
    }

    public Criteria andSubmitterIdNotEqualToOrIsNull(long value) {
      return andSubmitterIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andSubmitterIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceDAO.SubmitterId + " is null OR " + IWorkspaceDAO.SubmitterId + " <>",
          value,
          "submitterId");
      return this;
    }

    public Criteria andSubmitterIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.SubmitterId);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andSubmitterIdNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.SubmitterId + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andSubmitterIdGreaterThan(long value) {
      return andSubmitterIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andSubmitterIdGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceDAO.SubmitterId + " >", value, "submitterId");
      return this;
    }

    public Criteria andSubmitterIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.SubmitterId);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andSubmitterIdGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.SubmitterId + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andSubmitterIdGreaterThanOrEqualTo(long value) {
      return andSubmitterIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andSubmitterIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceDAO.SubmitterId + " >=", value, "submitterId");
      return this;
    }

    public Criteria andSubmitterIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.SubmitterId);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andSubmitterIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.SubmitterId + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andSubmitterIdLessThan(long value) {
      return andSubmitterIdLessThan(Long.valueOf(value));
    }

    public Criteria andSubmitterIdLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceDAO.SubmitterId + " <", value, "submitterId");
      return this;
    }

    public Criteria andSubmitterIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.SubmitterId);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andSubmitterIdLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.SubmitterId + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andSubmitterIdLessThanOrEqualTo(long value) {
      return andSubmitterIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andSubmitterIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceDAO.SubmitterId + " <=", value, "submitterId");
      return this;
    }

    public Criteria andSubmitterIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.SubmitterId);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andSubmitterIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.SubmitterId + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andSubmitterIdIn(long[] values) {
      if (values.length == 1) {
        return andSubmitterIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceDAO.SubmitterId + " in", values, "submitterId");
        return this;
      }
    }

    public Criteria andSubmitterIdNotIn(long[] values) {
      if (values.length == 1) {
        return andSubmitterIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceDAO.SubmitterId + " not in", values, "submitterId");
        return this;
      }
    }

    public Criteria andSubmitterIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andSubmitterIdEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceDAO.SubmitterId + " in", values, "submitterId");
        return this;
      }
    }

    public Criteria andSubmitterIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andSubmitterIdNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceDAO.SubmitterId + " not in", values, "submitterId");
        return this;
      }
    }

    public Criteria andSubmitterIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andSubmitterIdEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceDAO.SubmitterId + " in", Arrays.asList(values), "submitterId");
        return this;
      }
    }

    public Criteria andSubmitterIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andSubmitterIdNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceDAO.SubmitterId + " not in", Arrays.asList(values), "submitterId");
        return this;
      }
    }

    public Criteria andSubmitterIdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.SubmitterId + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andSubmitterIdNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.SubmitterId + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andSubmitterIdBetween(long value1, long value2) {
      addCriterion(IWorkspaceDAO.SubmitterId + " between", value1, value2, "submitterId");
      return this;
    }

    public Criteria andSubmitterIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceDAO.SubmitterId + " between", value1, value2, "submitterId");
      return this;
    }

    public Criteria andSubmitterIdNotBetween(long value1, long value2) {
      addCriterion(IWorkspaceDAO.SubmitterId + " not between", value1, value2, "submitterId");
      return this;
    }

    public Criteria andSubmitterIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceDAO.SubmitterId + " not between", value1, value2, "submitterId");
      return this;
    }

    public Criteria andCreatorNameIsNull() {
      addCriterion(IWorkspaceDAO.CreatorName + " is null");
      return this;
    }

    public Criteria andCreatorNameIsNotNull() {
      addCriterion(IWorkspaceDAO.CreatorName + " is not null");
      return this;
    }

    public Criteria andCreatorNameIsNotEmpty() {
      addCriterion(
          IWorkspaceDAO.CreatorName + " is not null AND " + IWorkspaceDAO.CreatorName + " <> ''");
      return this;
    }

    public Criteria andCreatorNameIsEmpty() {
      addCriterion(
          "(" + IWorkspaceDAO.CreatorName + " is null OR " + IWorkspaceDAO.CreatorName + " = '')");
      return this;
    }

    public Criteria andCreatorNameEqualTo(String value) {

      addCriterion(IWorkspaceDAO.CreatorName + " = ", value, "creatorName");
      return this;
    }

    public Criteria andCreatorNameEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.CreatorName);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCreatorNameEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.CreatorName + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andCreatorNameNotEqualTo(String value) {

      addCriterion(IWorkspaceDAO.CreatorName + " <>", value, "creatorName");
      return this;
    }

    public Criteria andCreatorNameNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceDAO.CreatorName + " is null OR " + IWorkspaceDAO.CreatorName + " <>",
          value,
          "creatorName");
      return this;
    }

    public Criteria andCreatorNameNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.CreatorName);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCreatorNameNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.CreatorName + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andCreatorNameGreaterThan(String value) {

      addCriterion(IWorkspaceDAO.CreatorName + " >", value, "creatorName");
      return this;
    }

    public Criteria andCreatorNameGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.CreatorName);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCreatorNameGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.CreatorName + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andCreatorNameGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceDAO.CreatorName + " >=", value, "creatorName");
      return this;
    }

    public Criteria andCreatorNameGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.CreatorName);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCreatorNameGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.CreatorName + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCreatorNameLessThan(String value) {

      addCriterion(IWorkspaceDAO.CreatorName + " <", value, "creatorName");
      return this;
    }

    public Criteria andCreatorNameLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.CreatorName);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCreatorNameLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.CreatorName + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andCreatorNameLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceDAO.CreatorName + " <=", value, "creatorName");
      return this;
    }

    public Criteria andCreatorNameLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.CreatorName);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCreatorNameLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.CreatorName + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCreatorNameLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceDAO.CreatorName + " like", buffer.toString(), "creatorName");
      return this;
    }

    public Criteria andCreatorNameNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceDAO.CreatorName + " not like", buffer.toString(), "creatorName");
      return this;
    }

    public Criteria andCreatorNameIn(List<String> values) {

      if (values.size() == 1) {
        return andCreatorNameEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceDAO.CreatorName + " in", values, "creatorName");
        return this;
      }
    }

    public Criteria andCreatorNameNotIn(List<String> values) {
      if (values.size() == 1) {
        return andCreatorNameNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceDAO.CreatorName + " not in", values, "creatorName");
        return this;
      }
    }

    public Criteria andCreatorNameIn(String[] values) {

      if (values.length == 1) {
        return andCreatorNameEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceDAO.CreatorName + " in", Arrays.asList(values), "creatorName");
        return this;
      }
    }

    public Criteria andCreatorNameNotIn(String[] values) {
      if (values.length == 1) {
        return andCreatorNameNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceDAO.CreatorName + " not in", Arrays.asList(values), "creatorName");
        return this;
      }
    }

    public Criteria andCreatorNameIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.CreatorName + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCreatorNameNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.CreatorName + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCreatorNameBetween(String value1, String value2) {
      addCriterion(IWorkspaceDAO.CreatorName + " between", value1, value2, "creatorName");
      return this;
    }

    public Criteria andCreatorNameNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceDAO.CreatorName + " not between", value1, value2, "creatorName");
      return this;
    }

    public Criteria andLastModifierNameIsNull() {
      addCriterion(IWorkspaceDAO.LastModifierName + " is null");
      return this;
    }

    public Criteria andLastModifierNameIsNotNull() {
      addCriterion(IWorkspaceDAO.LastModifierName + " is not null");
      return this;
    }

    public Criteria andLastModifierNameIsNotEmpty() {
      addCriterion(
          IWorkspaceDAO.LastModifierName
              + " is not null AND "
              + IWorkspaceDAO.LastModifierName
              + " <> ''");
      return this;
    }

    public Criteria andLastModifierNameIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceDAO.LastModifierName
              + " is null OR "
              + IWorkspaceDAO.LastModifierName
              + " = '')");
      return this;
    }

    public Criteria andLastModifierNameEqualTo(String value) {

      addCriterion(IWorkspaceDAO.LastModifierName + " = ", value, "lastModifierName");
      return this;
    }

    public Criteria andLastModifierNameEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.LastModifierName);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifierNameEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.LastModifierName + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifierNameNotEqualTo(String value) {

      addCriterion(IWorkspaceDAO.LastModifierName + " <>", value, "lastModifierName");
      return this;
    }

    public Criteria andLastModifierNameNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceDAO.LastModifierName + " is null OR " + IWorkspaceDAO.LastModifierName + " <>",
          value,
          "lastModifierName");
      return this;
    }

    public Criteria andLastModifierNameNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.LastModifierName);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifierNameNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.LastModifierName + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifierNameGreaterThan(String value) {

      addCriterion(IWorkspaceDAO.LastModifierName + " >", value, "lastModifierName");
      return this;
    }

    public Criteria andLastModifierNameGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.LastModifierName);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifierNameGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.LastModifierName + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifierNameGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceDAO.LastModifierName + " >=", value, "lastModifierName");
      return this;
    }

    public Criteria andLastModifierNameGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.LastModifierName);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifierNameGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.LastModifierName + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifierNameLessThan(String value) {

      addCriterion(IWorkspaceDAO.LastModifierName + " <", value, "lastModifierName");
      return this;
    }

    public Criteria andLastModifierNameLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.LastModifierName);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifierNameLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.LastModifierName + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifierNameLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceDAO.LastModifierName + " <=", value, "lastModifierName");
      return this;
    }

    public Criteria andLastModifierNameLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.LastModifierName);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifierNameLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.LastModifierName + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifierNameLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceDAO.LastModifierName + " like", buffer.toString(), "lastModifierName");
      return this;
    }

    public Criteria andLastModifierNameNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceDAO.LastModifierName + " not like", buffer.toString(), "lastModifierName");
      return this;
    }

    public Criteria andLastModifierNameIn(List<String> values) {

      if (values.size() == 1) {
        return andLastModifierNameEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceDAO.LastModifierName + " in", values, "lastModifierName");
        return this;
      }
    }

    public Criteria andLastModifierNameNotIn(List<String> values) {
      if (values.size() == 1) {
        return andLastModifierNameNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceDAO.LastModifierName + " not in", values, "lastModifierName");
        return this;
      }
    }

    public Criteria andLastModifierNameIn(String[] values) {

      if (values.length == 1) {
        return andLastModifierNameEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceDAO.LastModifierName + " in", Arrays.asList(values), "lastModifierName");
        return this;
      }
    }

    public Criteria andLastModifierNameNotIn(String[] values) {
      if (values.length == 1) {
        return andLastModifierNameNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceDAO.LastModifierName + " not in", Arrays.asList(values), "lastModifierName");
        return this;
      }
    }

    public Criteria andLastModifierNameIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.LastModifierName + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifierNameNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.LastModifierName + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifierNameBetween(String value1, String value2) {
      addCriterion(IWorkspaceDAO.LastModifierName + " between", value1, value2, "lastModifierName");
      return this;
    }

    public Criteria andLastModifierNameNotBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceDAO.LastModifierName + " not between", value1, value2, "lastModifierName");
      return this;
    }

    public Criteria andLastModifyTimeIsNull() {
      addCriterion(IWorkspaceDAO.LastModifyTime + " is null");
      return this;
    }

    public Criteria andLastModifyTimeIsNotNull() {
      addCriterion(IWorkspaceDAO.LastModifyTime + " is not null");
      return this;
    }

    public Criteria andLastModifyTimeIsNotEmpty() {
      addCriterion(
          IWorkspaceDAO.LastModifyTime
              + " is not null AND "
              + IWorkspaceDAO.LastModifyTime
              + " <> ''");
      return this;
    }

    public Criteria andLastModifyTimeIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceDAO.LastModifyTime
              + " is null OR "
              + IWorkspaceDAO.LastModifyTime
              + " = '')");
      return this;
    }

    public Criteria andLastModifyTimeEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(IWorkspaceDAO.LastModifyTime + " = ", value, "lastModifyTime");
      return this;
    }

    public Criteria andLastModifyTimeEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.LastModifyTime);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifyTimeEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.LastModifyTime + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyTimeNotEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(IWorkspaceDAO.LastModifyTime + " <>", value, "lastModifyTime");
      return this;
    }

    public Criteria andLastModifyTimeNotEqualToOrIsNull(java.util.Date value) {

      addCriterionForJDBCDate(
          IWorkspaceDAO.LastModifyTime + " is null OR " + IWorkspaceDAO.LastModifyTime + " <>",
          value,
          "lastModifyTime");
      return this;
    }

    public Criteria andLastModifyTimeNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.LastModifyTime);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifyTimeNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.LastModifyTime + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyTimeGreaterThan(java.util.Date value) {

      addCriterionForJDBCDate(IWorkspaceDAO.LastModifyTime + " >", value, "lastModifyTime");
      return this;
    }

    public Criteria andLastModifyTimeGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.LastModifyTime);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifyTimeGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.LastModifyTime + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyTimeGreaterThanOrEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(IWorkspaceDAO.LastModifyTime + " >=", value, "lastModifyTime");
      return this;
    }

    public Criteria andLastModifyTimeGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.LastModifyTime);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifyTimeGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.LastModifyTime + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyTimeLessThan(java.util.Date value) {

      addCriterionForJDBCDate(IWorkspaceDAO.LastModifyTime + " <", value, "lastModifyTime");
      return this;
    }

    public Criteria andLastModifyTimeLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.LastModifyTime);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifyTimeLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.LastModifyTime + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyTimeLessThanOrEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(IWorkspaceDAO.LastModifyTime + " <=", value, "lastModifyTime");
      return this;
    }

    public Criteria andLastModifyTimeLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceDAO.LastModifyTime);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLastModifyTimeLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.LastModifyTime + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyTimeIn(List<java.util.Date> values) {

      if (values.size() == 1) {
        return andLastModifyTimeEqualTo(values.get(0));
      } else {
        addCriterionForJDBCDate(IWorkspaceDAO.LastModifyTime + " in", values, "lastModifyTime");
        return this;
      }
    }

    public Criteria andLastModifyTimeNotIn(List<java.util.Date> values) {
      if (values.size() == 1) {
        return andLastModifyTimeNotEqualTo(values.get(0));
      } else {
        addCriterionForJDBCDate(IWorkspaceDAO.LastModifyTime + " not in", values, "lastModifyTime");
        return this;
      }
    }

    public Criteria andLastModifyTimeIn(java.util.Date[] values) {

      if (values.length == 1) {
        return andLastModifyTimeEqualTo(values[0]);
      } else {
        addCriterionForJDBCDate(
            IWorkspaceDAO.LastModifyTime + " in", Arrays.asList(values), "lastModifyTime");
        return this;
      }
    }

    public Criteria andLastModifyTimeNotIn(java.util.Date[] values) {
      if (values.length == 1) {
        return andLastModifyTimeNotEqualTo(values[0]);
      } else {
        addCriterionForJDBCDate(
            IWorkspaceDAO.LastModifyTime + " not in", Arrays.asList(values), "lastModifyTime");
        return this;
      }
    }

    public Criteria andLastModifyTimeIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.LastModifyTime + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyTimeNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceDAO.LastModifyTime + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andLastModifyTimeBetween(java.util.Date value1, java.util.Date value2) {
      addCriterionForJDBCDate(
          IWorkspaceDAO.LastModifyTime + " between", value1, value2, "lastModifyTime");
      return this;
    }

    public Criteria andLastModifyTimeNotBetween(java.util.Date value1, java.util.Date value2) {
      addCriterionForJDBCDate(
          IWorkspaceDAO.LastModifyTime + " not between", value1, value2, "lastModifyTime");
      return this;
    }
  }
}
